package com.spark.client.tool;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.spark.client.exception.SparkClientException;
import com.spark.client.model.SparkResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

/**
 * 工具调用处理器
 * 负责处理函数调用的执行和结果返回
 */
public class ToolCallHandler {
    
    private static final Logger logger = LoggerFactory.getLogger(ToolCallHandler.class);
    private static final ObjectMapper objectMapper = new ObjectMapper();
    
    private final Map<String, Function<Map<String, Object>, Object>> functionRegistry;

    public ToolCallHandler() {
        this.functionRegistry = new HashMap<>();
    }

    /**
     * 注册函数
     * @param functionName 函数名称
     * @param function 函数实现
     */
    public void registerFunction(String functionName, Function<Map<String, Object>, Object> function) {
        functionRegistry.put(functionName, function);
        logger.info("注册函数: {}", functionName);
    }

    /**
     * 处理工具调用
     * @param response 包含工具调用的响应
     * @return 工具调用结果
     * @throws SparkClientException
     */
    public Map<String, Object> handleToolCalls(SparkResponse response) throws SparkClientException {
        Map<String, Object> results = new HashMap<>();
        
        if (response.getChoices() == null || response.getChoices().isEmpty()) {
            return results;
        }
        
        for (SparkResponse.Choice choice : response.getChoices()) {
            if (choice.getMessage() != null && choice.getMessage().getContent() != null) {
                // 检查是否包含工具调用
                // 这里需要根据实际的响应格式来解析工具调用
                // 暂时简化处理
            }
            
            if (choice.getDelta() != null && choice.getDelta().getToolCalls() != null) {
                for (SparkResponse.ToolCall toolCall : choice.getDelta().getToolCalls()) {
                    if ("function".equals(toolCall.getType()) && toolCall.getFunction() != null) {
                        Object result = executeFunction(toolCall.getFunction());
                        results.put(toolCall.getId(), result);
                    }
                }
            }
        }
        
        return results;
    }

    /**
     * 执行函数调用
     * @param function 函数调用信息
     * @return 执行结果
     * @throws SparkClientException
     */
    private Object executeFunction(SparkResponse.Function function) throws SparkClientException {
        String functionName = function.getName();
        String arguments = function.getArguments();
        
        logger.info("执行函数: {}, 参数: {}", functionName, arguments);
        
        Function<Map<String, Object>, Object> registeredFunction = functionRegistry.get(functionName);
        if (registeredFunction == null) {
            throw new SparkClientException("未找到注册的函数: " + functionName);
        }
        
        try {
            // 解析参数
            Map<String, Object> params = objectMapper.readValue(arguments, Map.class);
            
            // 执行函数
            Object result = registeredFunction.apply(params);
            
            logger.info("函数 {} 执行完成，结果: {}", functionName, result);
            return result;
            
        } catch (Exception e) {
            logger.error("执行函数 {} 失败", functionName, e);
            throw new SparkClientException("函数执行失败: " + e.getMessage(), e);
        }
    }

    /**
     * 创建函数工具定义
     * @param name 函数名称
     * @param description 函数描述
     * @param properties 参数属性定义
     * @param required 必需参数列表
     * @return SparkTool
     */
    public static SparkTool createFunctionTool(String name, String description, 
                                               Map<String, Object> properties, 
                                               String[] required) {
        Map<String, Object> parameters = new HashMap<>();
        parameters.put("type", "object");
        parameters.put("properties", properties);
        if (required != null && required.length > 0) {
            parameters.put("required", required);
        }
        
        return SparkTool.function(name, description, parameters);
    }

    /**
     * 创建字符串参数定义
     * @param description 参数描述
     * @return 参数定义
     */
    public static Map<String, Object> stringProperty(String description) {
        Map<String, Object> property = new HashMap<>();
        property.put("type", "string");
        property.put("description", description);
        return property;
    }

    /**
     * 创建数字参数定义
     * @param description 参数描述
     * @return 参数定义
     */
    public static Map<String, Object> numberProperty(String description) {
        Map<String, Object> property = new HashMap<>();
        property.put("type", "number");
        property.put("description", description);
        return property;
    }

    /**
     * 创建整数参数定义
     * @param description 参数描述
     * @return 参数定义
     */
    public static Map<String, Object> integerProperty(String description) {
        Map<String, Object> property = new HashMap<>();
        property.put("type", "integer");
        property.put("description", description);
        return property;
    }

    /**
     * 创建布尔参数定义
     * @param description 参数描述
     * @return 参数定义
     */
    public static Map<String, Object> booleanProperty(String description) {
        Map<String, Object> property = new HashMap<>();
        property.put("type", "boolean");
        property.put("description", description);
        return property;
    }

    /**
     * 创建枚举参数定义
     * @param description 参数描述
     * @param enumValues 枚举值
     * @return 参数定义
     */
    public static Map<String, Object> enumProperty(String description, String[] enumValues) {
        Map<String, Object> property = new HashMap<>();
        property.put("type", "string");
        property.put("description", description);
        property.put("enum", enumValues);
        return property;
    }

    /**
     * 获取已注册的函数列表
     * @return 函数名称集合
     */
    public java.util.Set<String> getRegisteredFunctions() {
        return functionRegistry.keySet();
    }

    /**
     * 移除注册的函数
     * @param functionName 函数名称
     */
    public void unregisterFunction(String functionName) {
        functionRegistry.remove(functionName);
        logger.info("移除函数: {}", functionName);
    }

    /**
     * 清空所有注册的函数
     */
    public void clearFunctions() {
        functionRegistry.clear();
        logger.info("清空所有注册的函数");
    }
}
